home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / postgres / postgre4.z / postgre4 / src / planner / util / clauses.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-27  |  11.3 KB  |  561 lines
  1.  
  2. /*    
  3.  *        clauses
  4.  *    
  5.  *        Clause access and manipulation routines
  6.  *    $Header: /private/postgres/src/planner/util/RCS/clauses.c,v 1.19 1992/08/16 03:30:20 mer Exp $
  7.  */
  8.  
  9. /*    
  10.  *            clause-type
  11.  *            make-clause
  12.  *            is_opclause
  13.  *            make_opclause
  14.  *            get_opargs
  15.  *            get_op
  16.  *            get_leftop
  17.  *            get_rightop
  18.  *            is_funcclause
  19.  *            make_funcclause
  20.  *            get_funcargs
  21.  *            get_function
  22.  *            or_clause
  23.  *            make_orclause
  24.  *            get_orclauseargs
  25.  *            not_clause
  26.  *            make_notclause
  27.  *            get_notclausearg
  28.  *            and_clause
  29.  *            make_andclauseargs
  30.  *            get_andclauseargs
  31.  */
  32.  
  33.  
  34.  
  35. #include "tmp/c.h"
  36.  
  37. #include "parser/parse.h"
  38. #include "utils/log.h"
  39.  
  40. #include "nodes/pg_lisp.h"
  41. #include "catalog/pg_aggregate.h"
  42. #include "catalog/syscache.h"
  43.  
  44. #include "planner/clauses.h"
  45.  
  46. /*    
  47.  *        clause_head
  48.  *    
  49.  *        Returns the first element of a clause, if it is a clause
  50.  *    
  51.  */
  52.  
  53. /*  .. and_clause, clause-type, is_funcclause, is_opclause, not_clause
  54.  *  .. or_clause
  55.  */
  56. LispValue
  57. clause_head (clause)
  58.      LispValue clause ;
  59. {
  60.     if ( consp (clause) ) {
  61.     return(CAR (clause));
  62.     } else {
  63.     return(LispNil);
  64.     } 
  65. }
  66.  
  67. /*  .. clause-args, fix-indxqual-references
  68.  */
  69. LispValue
  70. clause_type (clause)
  71.      LispValue clause ;
  72. {
  73.     LispValue clauseand = lispInteger(AND);
  74.     LispValue clauseor = lispInteger(OR);
  75.     LispValue clausenot = lispInteger(NOT);
  76.     
  77.     if ( consp (clause) ) {
  78.     LispValue type = clause_head (clause);
  79.     if (type == LispNil) return(LispNil);
  80.     if ( member (type,lispCons(clauseand,
  81.                    lispCons(clauseor,
  82.                         lispCons(clausenot,
  83.                              LispNil)))) ||
  84.         IsA (type,Func) || IsA (type,Oper)) 
  85.       return(type);
  86.     } else
  87.       return(LispNil);
  88.  
  89.     return(LispNil);
  90. }
  91. /*  .. clause-subclauses
  92.  */
  93. LispValue
  94. clause_args (clause)
  95.      LispValue clause ;
  96. {
  97.     LispValue clauseand = lispInteger(AND);
  98.     LispValue clauseor = lispInteger(OR);
  99.     LispValue clausenot = lispInteger(NOT);
  100.  
  101.     if ( consp (clause) ) {
  102.     LispValue type = clause_type (clause);
  103.     if ( member (type,lispCons(clauseand,
  104.                    lispCons(clauseor,
  105.                         lispCons(clausenot,
  106.                              LispNil)))) ||
  107.         IsA (type,Func) || IsA(type,Oper) ) 
  108.       return(CDR (clause));
  109.     } else 
  110.       return(LispNil);
  111.  
  112.     return(LispNil);
  113. }
  114.  
  115.  
  116. LispValue
  117. make_clause (type,args)
  118.      LispValue type,args ;
  119. {
  120.     LispValue clauseand = lispInteger(AND);
  121.     LispValue clauseor = lispInteger(OR);
  122.     LispValue clausenot = lispInteger(NOT);
  123.  
  124.     if (null(type))
  125.       return(args);
  126.     else if (IsA(type,LispInt) ) {
  127.     int actual = CInteger(type);
  128.     if (actual == AND || actual == OR || actual == NOT)
  129.       return(lispCons(type,args));
  130.     } else if (IsA(type,Func) || IsA(type,Oper)) {
  131.     return(lispCons(type,args));
  132.  
  133.  
  134.     } else
  135.       return (args);
  136.  
  137.     return (args);
  138. }
  139.  
  140.  
  141. /*  .. fix-indxqual-references
  142.  */
  143.  
  144. LispValue
  145. clause_subclauses (type,clause)
  146.      LispValue type,clause ;
  147. {
  148.      if(type) {
  149.       return(clause_args (clause));
  150.      } else if (consp (clause)) {
  151.       return(clause);
  152.      } else
  153.        return(LispNil);
  154. }
  155.  
  156. /*        -------- OPERATOR clause macros
  157.  */
  158.  
  159. /*    
  160.  *        is_opclause
  161.  *    
  162.  *        Returns t iff the clause is an operator clause:
  163.  *            (op expr expr) or (op expr).
  164.  *    
  165.  */
  166.  
  167. /*  .. fix-indxqual-references
  168.  */
  169. bool
  170. is_opclause (clause)
  171.      LispValue clause ;
  172. {
  173.     if (clause_head(clause))
  174.       return((bool)IsA (clause_head (clause),Oper));
  175.  
  176.     return(false);
  177. }
  178.  
  179. /*    
  180.  *        make_opclause
  181.  *    
  182.  *        Creates a clause given its operator left operand and right
  183.  *        operand (if it is non-null).
  184.  *    
  185.  */
  186.  
  187. /*  .. fix-indxqual-references
  188.  */
  189. LispValue
  190. make_opclause (op,leftop,rightop)
  191.      Oper op;
  192.      Var leftop,rightop ;
  193. {
  194.      if(rightop) {
  195.       return(lispCons ((LispValue)op,
  196.                lispCons((LispValue)leftop,
  197.                     lispCons((LispValue)rightop,
  198.                          LispNil))));
  199.      } else {
  200.       return(lispCons ((LispValue)op,
  201.                lispCons((LispValue)leftop,LispNil)));
  202.      }
  203. }
  204.  
  205. /*    
  206.  *        get_opargs
  207.  *    
  208.  *        Returns the argument exprs of an op clause.
  209.  *    
  210.  */
  211.  
  212. LispValue
  213. get_opargs (clause)
  214.      LispValue clause ;
  215. {
  216.      return(CDR (clause));
  217. }
  218.  
  219. /*    
  220.  *        get_op
  221.  *    
  222.  *        Returns the operator in a clause of the form (op expr expr) or
  223.  *        (op expr)
  224.  *    
  225.  */
  226.  
  227. LispValue
  228. get_op (clause)
  229.      LispValue clause ;
  230. {
  231.      return(nth (0,clause));
  232. }
  233.  
  234. /*    
  235.  *        get_leftop
  236.  *    
  237.  *        Returns the left operand of a clause of the form (op expr expr)
  238.  *        or (op expr)
  239.  *      NB: it is assumed (for now) that all expr must be Var nodes    
  240.  */
  241.  
  242. Var
  243. get_leftop (clause)
  244.      LispValue clause ;
  245. {
  246.      return((Var)nth (1,clause));
  247. }
  248.  
  249. /*    
  250.  *        get_rightop
  251.  *    
  252.  *        Returns the right operand in a clause of the form (op expr expr).
  253.  *    
  254.  */
  255.  
  256. Var
  257. get_rightop (clause)
  258.      LispValue clause ;
  259. {
  260.      clause = CDR(CDR(clause));
  261.  
  262.      return( (Var)((clause) ? CAR(clause) : LispNil) );
  263. }
  264. /* ----Agg clause macros
  265. */
  266. bool
  267. agg_clause(clause)
  268.     LispValue clause;
  269. {
  270.     char *keyword = "agg";
  271.     LispValue temp;
  272.     int tempstring;
  273.     if(listp(clause)){
  274.          temp = CAR(clause);
  275.          if(stringp(temp)) {
  276.                tempstring = (strcmp(keyword, CString(temp)));
  277.          if(!tempstring)
  278.             return(true);
  279.          }
  280.          }
  281.      /* if it is not a list, we're not dealing with aggregates
  282.       * anyway.
  283.       */
  284.       return(false);
  285. }
  286.  
  287.  
  288. /*        -------- FUNC clause macros
  289.  */
  290.  
  291. /*    
  292.  *        is_funcclause
  293.  *    
  294.  *        Returns t iff the clause is a function clause: (func { expr }).
  295.  *    
  296.  */
  297.  
  298. /*  .. ExecEvalExpr, fix-indxqual-references, fix-opid, flatten-tlistentry
  299.  *  .. nested-clause-p, print_clause, pull_var_clause
  300.  *  .. replace-clause-joinvar-refs, replace-clause-nestvar-refs
  301.  *  .. replace-clause-resultvar-refs
  302.  */
  303.  
  304. bool
  305. is_funcclause (clause)
  306.      LispValue clause ;
  307. {
  308.     if (clause_head(clause))
  309.       return((bool)IsA (clause_head (clause),Func));
  310.     return(false);
  311. }
  312.  
  313. /*    
  314.  *        make_funcclause
  315.  *    
  316.  *        Creates a function clause given the FUNC node and the functional
  317.  *        arguments.
  318.  *    
  319.  */
  320.  
  321. /*  .. flatten-tlistentry, replace-clause-joinvar-refs
  322.  *  .. replace-clause-nestvar-refs, replace-clause-resultvar-refs
  323.  */
  324. LispValue
  325. make_funcclause (func,funcargs)
  326.      LispValue func,funcargs ;
  327. {
  328.      return(lispCons (func,funcargs));
  329. }
  330.  
  331. /*    
  332.  *        get_function
  333.  *    
  334.  *        Returns the FUNC node from a function clause.
  335.  *    
  336.  */
  337.  
  338. /*  .. ExecEvalFunc, fix-indxqual-references, flatten-tlistentry
  339.  *  .. print_clause, replace-clause-joinvar-refs, replace-clause-nestvar-refs
  340.  *  .. replace-clause-resultvar-refs
  341.  */
  342.  
  343. LispValue
  344. get_function (func)
  345.      LispValue func ;
  346. {
  347.      return(CAR (func));
  348. }
  349.  
  350. /*    
  351.  *        get_funcargs
  352.  *    
  353.  *        Returns the functional arguments from a function clause.
  354.  *    
  355.  */
  356.  
  357. /*  .. fix-opid, flatten-tlistentry, initialize-qualification
  358.  *  .. nested-clause-p, print_clause, pull_var_clause
  359.  *  .. replace-clause-joinvar-refs, replace-clause-nestvar-refs
  360.  *  .. replace-clause-resultvar-refs
  361.  */
  362. LispValue
  363. get_funcargs (func)
  364.      LispValue func ;
  365. {
  366.      return(CDR (func));
  367. }
  368.  
  369. /*        -------- OR clause macros
  370.  */
  371.  
  372. /*    
  373.  *        or_clause
  374.  *    
  375.  *        Returns t iff the clause is an 'or' clause: (OR { expr }).
  376.  *    
  377.  */
  378.  
  379. /*  .. ExecEvalExpr, cleanup, compute_clause_selec, contains-not
  380.  *  .. create_indexscan_node, find-nots, fix-opid, nested-clause-p
  381.  *  .. normalize, print_clause, pull-args, pull-ors, pull_var_clause
  382.  *  .. push-nots, relation-level-clause-p, remove-ands
  383.  *  .. replace-clause-joinvar-refs, replace-clause-nestvar-refs
  384.  *  .. replace-clause-resultvar-refs, valid-or-clause
  385.  * XXX - should be called or_clause_p instead
  386.  */
  387.  
  388. bool
  389. or_clause (clause)
  390.      LispValue clause ;
  391. {
  392.     if (consp (clause))
  393.       return(bool) ( equal((Node)lispInteger(OR),(Node)clause_head(clause)));
  394.    /*  return(equal ("OR",clause_head (clause))); */
  395.     return(false);
  396. }
  397.  
  398. /*    
  399.  *        make_orclause
  400.  *    
  401.  *        Creates an 'or' clause given a list of its subclauses.
  402.  *    
  403.  */
  404.  
  405. /*  .. cleanup, distribute-args, find-nots, normalize, pull-args
  406.  *  .. push-nots, remove-ands, replace-clause-joinvar-refs
  407.  *  .. replace-clause-nestvar-refs, replace-clause-resultvar-refs
  408.  */
  409. LispValue
  410. make_orclause (orclauses)
  411.      LispValue orclauses ;
  412. {
  413.     return(lispCons (lispInteger(OR),orclauses));
  414. }
  415.  
  416. /*    
  417.  *        get_orclauseargs
  418.  *    
  419.  *        Retrieves the subclauses of an 'or' clause.
  420.  *    
  421.  */
  422.  
  423. /*  .. ExecEvalExpr, cleanup, compute_clause_selec, contains-not
  424.  *  .. create-or-index-paths, create_indexscan_node, find-nots, fix-opid
  425.  *  .. match-index-orclauses, nested-clause-p, normalize, print_clause
  426.  *  .. pull-args, pull-ors, pull_var_clause, push-nots
  427.  *  .. relation-level-clause-p, remove-ands, replace-clause-joinvar-refs
  428.  *  .. replace-clause-nestvar-refs, replace-clause-resultvar-refs
  429.  */
  430. LispValue
  431. get_orclauseargs (orclause)
  432.      LispValue orclause ;
  433. {
  434.     if ( consp (orclause))
  435.       return(CDR (orclause));
  436.  
  437.     return(NULL);
  438. }
  439.  
  440. /*        -------- NOT clause macros
  441.  */
  442.  
  443. /*    
  444.  *        not_clause
  445.  *    
  446.  *        Returns t iff this is a 'not' clause: (NOT expr).
  447.  *    
  448.  */
  449.  
  450. /*  .. ExecEvalExpr, cleanup, compute_clause_selec, contains-not
  451.  *  .. find-nots, fix-opid, nested-clause-p, normalize, print_clause
  452.  *  .. pull-args, pull_var_clause, push-nots, relation-level-clause-p
  453.  *  .. remove-ands, replace-clause-joinvar-refs, replace-clause-nestvar-refs
  454.  *  .. replace-clause-resultvar-refs
  455.  */
  456. bool
  457. not_clause (clause)
  458.      LispValue clause ;
  459. {
  460.     if (consp (clause))
  461.       return(bool) ( equal((Node)lispInteger(NOT),(Node)clause_head(clause)));
  462.  
  463.     return(false);
  464. }
  465.  
  466. /*    
  467.  *        make_notclause
  468.  *    
  469.  *        Create a 'not' clause given the expression to be negated.
  470.  *    
  471.  */
  472.  
  473. /*  .. cleanup, normalize, pull-args, push-nots, remove-ands
  474.  *  .. replace-clause-joinvar-refs, replace-clause-nestvar-refs
  475.  *  .. replace-clause-resultvar-refs
  476.  */
  477. LispValue
  478. make_notclause (notclause)
  479. LispValue notclause ;
  480. {
  481.     return(lispCons (lispInteger(NOT),
  482.              lispCons(notclause,LispNil))); 
  483. }
  484.  
  485. /*    
  486.  *        get_notclausearg
  487.  *    
  488.  *        Retrieve the clause within a 'not' clause
  489.  *    
  490.  */
  491.  
  492. /*  .. ExecEvalNot, cleanup, compute_clause_selec, find-nots, fix-opid
  493.  *  .. nested-clause-p, normalize, print_clause, pull-args
  494.  *  .. pull_var_clause, push-nots, relation-level-clause-p, remove-ands
  495.  *  .. replace-clause-joinvar-refs, replace-clause-nestvar-refs
  496.  *  .. replace-clause-resultvar-refs
  497.  */
  498. LispValue
  499. get_notclausearg (notclause)
  500.      LispValue notclause ;
  501. {
  502.      return( CAR(CDR( (notclause)))) ;
  503. }
  504.  
  505. /*        -------- AND clause macros
  506.  */
  507.  
  508. /*    
  509.  *        and_clause
  510.  *    
  511.  *        Returns t iff its argument is an 'and' clause: (AND { expr }).
  512.  *    
  513.  */
  514.  
  515. /*  .. cleanup, cnfify, find-nots, normalize, pull-ands, pull-args
  516.  *  .. push-nots, remove-ands
  517.  */
  518. bool
  519. and_clause (clause)
  520.      LispValue clause ;
  521. {
  522.     if (consp (clause))
  523.       return(bool) ( equal((Node)lispInteger(AND),(Node)clause_head(clause)));
  524.  
  525.     return(false);
  526. }
  527.  
  528. /*             
  529.  *        make_andclause
  530.  *    
  531.  *        Create an 'and' clause given its arguments in a list.
  532.  *    
  533.  */
  534.  
  535. /*  .. cleanup, cnfify, distribute-args, find-nots, normalize
  536.  *  .. pull-args, push-nots
  537.  */
  538. LispValue
  539. make_andclause (andclauses)
  540.      LispValue andclauses ;
  541. {
  542.      return(lispCons (lispInteger(AND),andclauses));
  543. }
  544.  
  545. /*    
  546.  *        get_andclauseargs
  547.  *    
  548.  *        Retrieve the arguments of an 'and' clause.
  549.  *    
  550.  */
  551.  
  552. /*  .. cleanup, find-nots, normalize, or-normalize, pull-ands
  553.  *  .. pull-args, push-nots, remove-ands
  554.  */
  555. LispValue
  556. get_andclauseargs (andclause)
  557.      LispValue andclause ;
  558. {
  559.      return(CDR (andclause));
  560. }
  561.